package com.lxnj.util;

import java.io.InputStream;
import java.lang.reflect.Field;
import java.sql.*;
import java.util.*;

/**
 * jdbc工具类.
 * 在src的目录下必须包含有jdbc.properties文件
 */
public final class JdbcUtil {

    private static String driverClassName;
    private static String URL;
    private static String username;
    private static String password;

    /**
     * 声明一个 Connection类型的静态属性，用来缓存一个已经存在的连接对象
     */
    private static Connection conn;

    static {
        config();
    }

    /**
     * 开头配置自己的数据库信息
     */
    private static void config() {
        try {
            InputStream inStream = JdbcUtil.class
                    .getResourceAsStream("/jdbc.properties");
            Properties prop = new Properties();
            prop.load(inStream);
            /*
             * 获取驱动
             */
            driverClassName= prop.getProperty("jdbc.driver");
            /*
             * 获取URL
             */
            URL = prop.getProperty("jdbc.url");
            /*
             * 获取用户名
             */
            username = prop.getProperty("jdbc.username");
            /*
             * 获取密码
             */
            password = prop.getProperty("jdbc.password");
        } catch (Exception e) {
            throw new RuntimeException("读取数据库配置文件异常！", e);
        }

    }

    /**
     * 载入数据库驱动类
     */
    private static boolean load() {
        try {
            Class.forName(driverClassName);
            return true;
        } catch (ClassNotFoundException e) {
            System.out.println("驱动类 " + driverClassName + " 加载失败");
        }

        return false;
    }

    /**
     * 专门检查缓存的连接是否不可以被使用 ，不可以被使用的话，就返回 true
     */
    private static boolean invalid() {
        if (conn != null) {
            try {
                if (conn.isClosed() || !conn.isValid(3)) {
                    /*
                     * isValid方法是判断Connection是否有效,如果连接尚未关闭并且仍然有效，则返回 true
                     */
                    return true;
                }
            } catch (SQLException e) {
                e.printStackTrace();
            }
            /*
             * conn 既不是 null 且也没有关闭 ，且 isValid 返回 true，说明是可以使用的 ( 返回 false )
             */
            return false;
        } else {
            return true;
        }
    }

    /**
     * 建立数据库连接
     */
    private static Connection connect() {
        if (invalid()) { /* invalid为true时，说明连接是失败的 */
            /* 加载驱动 */
            load();
            try {
                /* 建立连接 */
                conn = DriverManager.getConnection(URL, username, password);
                /* 设置事务的提交方式为手动提交 */
                conn.setAutoCommit(false);
            } catch (SQLException e) {
                System.out.println("建立数据库连接失败 , " + e.getMessage());
            }
        }
        return conn;
    }


    /**
     * 创建 Statement 对象
     */
    private static Statement statement() {
        Statement st = null;
        connect();
        try {
            st = conn.createStatement();
        } catch (SQLException e) {
            System.out.println("创建 Statement 对象失败: " + e.getMessage());
        }

        return st;
    }

    /**
     * 根据给定的带参数占位符的SQL语句，创建 PreparedStatement 对象
     *
     * @param SQL 带参数占位符的SQL语句
     * @return 返回相应的 PreparedStatement 对象
     */
    private static PreparedStatement prepare(String SQL, boolean autoGeneratedKeys) {
        PreparedStatement ps = null;
        connect();
        try {
            if (autoGeneratedKeys) {
                ps = conn.prepareStatement(SQL, Statement.RETURN_GENERATED_KEYS);
            } else {
                ps = conn.prepareStatement(SQL);
            }
        } catch (SQLException e) {
            System.out.println("创建 PreparedStatement 对象失败: " + e.getMessage());
        }

        return ps;

    }


    public static ResultSet query(String SQL, Object... params) {
        if (SQL == null || SQL.trim().isEmpty() || !SQL.trim().toLowerCase().startsWith("select")) {
            throw new RuntimeException("你的SQL语句为空或不是查询语句");
        }
        ResultSet rs = null;
        if (params.length > 0) {
            /* 说明 有参数 传入，就需要处理参数 */
            PreparedStatement ps = prepare(SQL, false);
            try {
                for (int i = 0; i < params.length; i++) {
                    ps.setObject(i + 1, params[i]);
                }
                rs = ps.executeQuery();
            } catch (SQLException e) {
                System.out.println("执行SQL失败: " + e.getMessage());
            } finally {
                release(rs);
                release(ps);
            }
        } else {
            /* 说明没有传入任何参数 */
            Statement st = statement();
            try {
                rs = st.executeQuery(SQL); // 直接执行不带参数的 SQL 语句
            } catch (SQLException e) {
                System.out.println("执行SQL失败: " + e.getMessage());
            }finally {
                release(st);
            }
        }
        return rs;
    }

    /**
     * 用于insert、update、delete或者其它
     * @param SQL
     * @param params
     * @return 返回受影响的行数
     */
    public static int execute(String SQL, Object... params) {
        if (SQL == null || SQL.trim().isEmpty() || SQL.trim().toLowerCase().startsWith("select")) {
            throw new RuntimeException("你的SQL语句为空或有错");
        }

        int rows = -1; //受影响的行数
        if (params.length > 0) { // 说明有参数
            PreparedStatement ps = prepare(SQL, false);
            Connection c = null;
            try {
                c = ps.getConnection();
            } catch (SQLException e) {
                e.printStackTrace();
            }
            try {
                for (int i = 0; i < params.length; i++) {
                    Object p = params[i];
                    p = typeof(p);
                    ps.setObject(i + 1, p);
                }
                rows = ps.executeUpdate();
                commit(c);
            } catch (SQLException e) {
                System.out.println("操作失败: " + e.getMessage());
                rollback(c); // 回滚事务
            } finally {
                release(ps);
                release(c);
            }

        } else { // 说明没有参数
            Statement st = statement();
            Connection c = null;
            try {
                c = st.getConnection();
            } catch (SQLException e) {
                e.printStackTrace();
            }
            // 执行 DDL 或 DML 语句，并返回执行结果
            try {
                rows = st.executeUpdate(SQL);
                commit(c); // 提交事务
            } catch (SQLException e) {
                System.out.println("操作失败: " + e.getMessage());
                rollback(c); // 回滚事务
            } finally {
                release(c);
            }
        }
        return rows;
    }

    /* 
     *
     *  插入一条记录。如JdbcUtil.insert(SQL, true, "阿木侠","12345");
     * @param SQL 
     *            需要执行的 INSERT 语句 
     * @param autoGeneratedKeys 
     *            指示是否需要返回由数据库产生的键 
     * @param params 
     *            将要执行的SQL语句中包含的参数占位符的 参数值 
     * @return 如果指定 autoGeneratedKeys 为 true 则返回由数据库产生的键； 如果指定 autoGeneratedKeys 
     *         为 false 则返回受当前SQL影响的记录数目 
     */
    public static int insert(String SQL, boolean autoGeneratedKeys, Object... params) {
        int var = -1;
        if (SQL == null || SQL.trim().isEmpty()) {
            throw new RuntimeException("你没有指定SQL语句，请检查是否指定了需要执行的SQL语句");
        }
        // 如果不是 insert 开头开头的语句
        if (!SQL.trim().toLowerCase().startsWith("insert")) {
            System.out.println(SQL.toLowerCase());
            throw new RuntimeException("你指定的SQL语句不是插入语句，请检查你的SQL语句");
        }
        // 获得 被执行的 SQL 语句的 前缀 ( 第一个单词 )
        SQL = SQL.trim();
        SQL = SQL.toLowerCase();
        if (params.length > 0) { // 说明有参数
            PreparedStatement ps = prepare(SQL, autoGeneratedKeys);
            Connection c = null;
            try {
                c = ps.getConnection(); // 从 PreparedStatement 对象中获得 它对应的连接对象
            } catch (SQLException e) {
                e.printStackTrace();
            }
            try {
                for (int i = 0; i < params.length; i++) {
                    Object p = params[i];
                    p = typeof(p);
                    ps.setObject(i + 1, p);
                }
                int count = ps.executeUpdate();
                if (autoGeneratedKeys) { // 如果希望获得数据库产生的键
                    ResultSet rs = ps.getGeneratedKeys(); // 获得数据库产生的键集
                    if (rs.next()) { // 因为是保存的是单条记录，因此至多返回一个键
                        var = rs.getInt(1); // 获得值并赋值给 var 变量
                    }
                } else {
                    var = count; // 如果不需要获得，则将受SQL影像的记录数赋值给 var 变量
                }
                commit(c);
            } catch (SQLException e) {
                System.out.println("数据保存失败: " + e.getMessage());
                rollback(c); // 回滚事务
            } finally {
                release(ps);
                release(c);
            }
        } else { // 说明没有参数
            Statement st = statement();
            Connection c = null;
            try {
                c = st.getConnection(); // 从 Statement 对象中获得 它对应的连接对象
            } catch (SQLException e) {
                e.printStackTrace();
            }
            // 执行 DDL 或 DML 语句，并返回执行结果
            try {
                int count = st.executeUpdate(SQL);
                if (autoGeneratedKeys) { // 如果企望获得数据库产生的键
                    ResultSet rs = st.getGeneratedKeys(); // 获得数据库产生的键集
                    if (rs.next()) { // 因为是保存的是单条记录，因此至多返回一个键
                        var = rs.getInt(1); // 获得值并赋值给 var 变量
                    }
                } else {
                    var = count; // 如果不需要获得，则将受SQL影像的记录数赋值给 var 变量
                }
                commit(c); // 提交事务
            } catch (SQLException e) {
                System.out.println("数据保存失败: " + e.getMessage());
                rollback(c); // 回滚事务
            } finally {
                release(st);
                release(c);
            }
        }
        return var;
    }

    /*
     * 批量插入。
     *     如JdbcUtil.insertBatch(sqlList);
     * @param sqlList 需要执行的 INSERT 语句的集合
     */
    public static void insertBatch(List<String> sqlList) {
        long startTime = System.currentTimeMillis();
        Statement st = statement();
        Connection c = null;
        try {
            c = st.getConnection(); // 从 Statement 对象中获得 它对应的连接对象
        } catch (SQLException e) {
            e.printStackTrace();
        }

        try {
            for(String sql : sqlList) {
                if (sql == null || sql.trim().isEmpty()) {
                    continue;
                }

                if (!sql.trim().toLowerCase().startsWith("insert")) {
                    continue;
                }

                sql = sql.trim();
                sql = sql.toLowerCase();
                st.execute(sql);
            }

            commit(c); // 提交事务
            long endTime = System.currentTimeMillis();
            float excTime=(float)(endTime-startTime)/1000;
            System.out.println("执行时间："+excTime+"s");
            try {
                System.out.println("休息一下...");
                Thread.sleep(3*1000);
            } catch (InterruptedException e) {
                e.printStackTrace();
            }

        } catch (SQLException e) {
            System.out.println("数据保存失败: " + e.getMessage());
            rollback(c); // 回滚事务
        } finally {
            release(st);
            release(c);
        }

    }

    private static Object typeof(Object o) {
        Object r = o;
        if (o instanceof java.sql.Timestamp) {
            return r;
        }
        // 将 java.util.Date 转成 java.sql.Date
        if (o instanceof java.util.Date) {
            java.util.Date d = (java.util.Date) o;
            r = new java.sql.Date(d.getTime());
            return r;
        }
        // 将 Character 或 char 变成 String
        if (o instanceof Character || o.getClass() == char.class) {
            r = String.valueOf(o);
            return r;
        }
        return r;
    }


    /**
     * 提交事务
     */
    private static void commit(Connection c) {
        if (c != null) {
            try {
                c.commit();
            } catch (SQLException e) {
                e.printStackTrace();
            }
        }
    }

    /**
     * 回滚事务
     */
    private static void rollback(Connection c) {
        if (c != null) {
            try {
                c.rollback();
            } catch (SQLException e) {
                e.printStackTrace();
            }
        }
    }


    /**
     * 释放资源
     **/
    private static void release(Object cloaseable) {
        if (cloaseable != null) {
            if (cloaseable instanceof ResultSet) {
                ResultSet rs = (ResultSet) cloaseable;
                try {
                    rs.close();
                } catch (SQLException e) {
                    e.printStackTrace();

                }
            }

            if (cloaseable instanceof Statement) {
                Statement st = (Statement) cloaseable;
                try {
                    st.close();
                } catch (SQLException e) {
                    e.printStackTrace();
                }
            }

            if (cloaseable instanceof Connection) {
                Connection c = (Connection) cloaseable;
                try {
                    c.close();
                } catch (SQLException e) {
                    e.printStackTrace();
                }
            }

        }

    }

    /**
     * 传入 SQL 语句和 Class 对象, 返回 SQL 语句查询到的记录对应的 Class 类的对象的集合
     *
     * @param clazz:  对象的类型
     * @param sql:    SQL 语句
     * @param params: 填充 SQL 语句的占位符的可变参数.
     * @return
     */
    public static <T> List<T> queryForList(Class<T> clazz,
                                  String sql, Object... params) {
        List<T> list = new ArrayList<>();
        try {
            //得到结果集
            ResultSet resultSet = query(sql, params);

            //处理结果集, 得到 Map 的 List, 其中一个 Map 对象
            //就是一条记录. Map 的 key 为 reusltSet 中列的别名, Map 的 value为列的值.
            List<Map<String, Object>> values =
                    handleResultSetToMapList(resultSet);

            //把 Map 的 List 转为 clazz 对应的 List
            //其中 Map 的 key 即为 clazz 对应的对象的 propertyName,
            //而 Map 的 value 即为 clazz 对应的对象的 propertyValue
            list = transfterMapListToBeanList(clazz, values);

        } catch (Exception e) {
            e.printStackTrace();
        }

        return list;
    }


    /**
     * 处理结果集, 得到 Map 的一个 List, 其中一个 Map 对象对应一条记录
     *
     * @param resultSet
     * @return
     * @throws SQLException
     */
    private static List<Map<String, Object>> handleResultSetToMapList(
                                            ResultSet resultSet) throws SQLException {
        // 准备一个 List<Map<String, Object>>:
        // 键: 存放列的别名, 值: 存放列的值. 其中一个 Map 对象对应着一条记录
        List<Map<String, Object>> values = new ArrayList<>();

        List<String> columnLabels = getColumnLabels(resultSet);
        Map<String, Object> map;

        // 处理 ResultSet, 使用 while 循环
        while (resultSet.next()) {
            map = new HashMap<>();
            for (String columnLabel : columnLabels) {
                Object value = resultSet.getObject(columnLabel);
                map.put(columnLabel, value);
            }

            // 把一条记录的一个 Map 对象放入 5 准备的 List 中
            values.add(map);
        }
        return values;
    }

    /**
     * 转换List<Map> 为  List<T>
     *
     * @param clazz
     * @param values
     * @return
     * @throws InstantiationException
     * @throws IllegalAccessException
     */
    private static <T> List<T> transfterMapListToBeanList(Class<T> clazz,
                            List<Map<String, Object>> values) throws Exception {
        List<T> result = new ArrayList<>();
        T bean;
        if (values.size() > 0) {
            for (Map<String, Object> m : values) {
                //通过反射创建一个其他类的对象
                bean = clazz.newInstance();

                for (Map.Entry<String, Object> entry : m.entrySet()) {
                    String propertyName = entry.getKey();
                    Object value = entry.getValue();

                    Field f = bean.getClass().getDeclaredField(propertyName);
                    f.setAccessible(true);
                    f.set(bean, value);

                    //BeanUtils.setProperty(bean, propertyName, value);
                }
                // 把 Object 对象放入到 list 中.
                result.add(bean);
            }
        }

        return result;
    }

    /**
     * 获取结果集的 ColumnLabel 对应的 List
     *
     * @param rs
     * @return
     * @throws SQLException
     */
    private static List<String> getColumnLabels(ResultSet rs) throws SQLException {
        List<String> labels = new ArrayList<>();
        ResultSetMetaData rsmd = rs.getMetaData();
        for (int i = 0; i < rsmd.getColumnCount(); i++) {
            labels.add(rsmd.getColumnLabel(i + 1));
        }
        return labels;
    }

    public static void main(String[] args) {
        //批量插入
        List<String> sqlList = new ArrayList<>();
        sqlList.add("insert into NMS_ChanDataAscription(`rownumber`,`ID`,`AscriptionName`) values ('1','1','声强报警')");
        sqlList.add("insert into NMS_ChanDataAscription(`rownumber`,`ID`,`AscriptionName`) values ('2','2','人员定位')");
        sqlList.add("insert into NMS_ChanDataAscription(`rownumber`,`ID`,`AscriptionName`) values ('3','3','人脸识别')");
        sqlList.add("insert into NMS_ChanDataAscription(`rownumber`,`ID`,`AscriptionName`) values ('4','4','出入信息')");

        JdbcUtil.insertBatch(sqlList);

        //单条插入
        String SQL = "insert into user_info(username,password) value (?,?)";
        JdbcUtil.insert(SQL, true, "阿木侠","12345");

        //删除
        String SQL2 = "delete from user_info where username like '%"+username+"%'";
        JdbcUtil.execute(SQL2);

        //更新
        String SQL3 = "update user_info set password=? where id=2";
        JdbcUtil.execute(SQL3, "123321");


        //查询一
        String name = "阿木侠";
        String SQL4 = "select id,password from user_info where username= ?";
        ResultSet rs = JdbcUtil.query(SQL4,name);
        try {
            if(rs.next()){
                System.out.println(rs.getInt(1));
                System.out.println(name);
                System.out.println(rs.getString(2));
            }
        } catch (SQLException e) {
            e.printStackTrace();
        }

        //查询二
        String SQL5 = "select id,password from user_info where username= ?";
        List result = JdbcUtil.queryForList(Map.class, SQL5, name);
    }

} 